{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1b257a67",
   "metadata": {},
   "source": [
    "## 注意： 为了使用起来方便且不报错，修改点会指出来，请再次打开本文档时慎重修改提示点之外的修改。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fb485765",
   "metadata": {},
   "outputs": [],
   "source": [
    "EleGANt_dir = '../EleGANt'\n",
    "import sys\n",
    "sys.path.append(EleGANt_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5ec2841b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import cv2\n",
    "import torch\n",
    "import numpy as np\n",
    "import torch.utils.data as data\n",
    "from PIL import Image\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision.utils import save_image, make_grid\n",
    "from torchvision import transforms\n",
    "from torchvision.transforms import functional\n",
    "from einops import rearrange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7bac032a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from ele_models.loss import AnnealingComposePGT\n",
    "import faceutils as futils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "847705b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b928664f",
   "metadata": {},
   "source": [
    "## 修改点1 设置GPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "436bb726",
   "metadata": {},
   "outputs": [],
   "source": [
    "gpu_id = '2'\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = '2'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c3b71a73",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Inference(AnnealingComposePGT):\n",
    "    def __init__(self):\n",
    "        EYE_MARGIN = 12\n",
    "        LIP_MARGIN = 4\n",
    "        SKIN_ALPHA = 0.3\n",
    "        SKIN_ALPHA_MILESTONES = (0, 12, 24, 50)\n",
    "        SKIN_ALPHA_VALUES = (0.2, 0.4, 0.3, 0.2)\n",
    "        EYE_ALPHA = 0.8\n",
    "        EYE_ALPHA_MILESTONES = (0, 12, 24, 50)\n",
    "        EYE_ALPHA_VALUES = (0.6, 0.8, 0.6, 0.4)\n",
    "        LIP_ALPHA = 0.1\n",
    "        LIP_ALPHA_MILESTONES = (0, 12, 24, 50)\n",
    "        LIP_ALPHA_VALUES = (0.05, 0.2, 0.1, 0.0)\n",
    "        self.margins = {'eye': EYE_MARGIN, 'lip': LIP_MARGIN}\n",
    "        super().__init__(self.margins, SKIN_ALPHA_MILESTONES, SKIN_ALPHA_VALUES, EYE_ALPHA_MILESTONES,\n",
    "                         EYE_ALPHA_VALUES, LIP_ALPHA_MILESTONES, LIP_ALPHA_VALUES)\n",
    "        self.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "00b0e855",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PreProcess:\n",
    "\n",
    "    def __init__(self, need_parser=True, device='cpu', img_size=256, lmk_points=68, up_ratio=0.6/0.85, down_ratio=0.2/0.85,\n",
    "                 width_ratio=0.2/0.85, lip_class=[7,9], face_class=[1,6], eyebrow_class=[2,3], eye_class=[4,5]):\n",
    "        self.img_size = img_size \n",
    "        self.device = device\n",
    "\n",
    "        xs, ys = np.meshgrid(\n",
    "            np.linspace(\n",
    "                0, self.img_size - 1,\n",
    "                self.img_size\n",
    "            ),\n",
    "            np.linspace(\n",
    "                0, self.img_size - 1,\n",
    "                self.img_size\n",
    "            )\n",
    "        )\n",
    "        xs = xs[None].repeat(lmk_points, axis=0)\n",
    "        ys = ys[None].repeat(lmk_points, axis=0)\n",
    "        fix = np.concatenate([ys, xs], axis=0) \n",
    "        self.fix = torch.Tensor(fix) #(136, h, w)\n",
    "        if need_parser:\n",
    "            self.face_parse = futils.mask.FaceParser(device=device)\n",
    "        self.up_ratio    = up_ratio\n",
    "        self.down_ratio  = down_ratio\n",
    "        self.width_ratio = width_ratio\n",
    "        self.lip_class   = lip_class\n",
    "        self.face_class  = face_class\n",
    "        self.eyebrow_class  = eyebrow_class\n",
    "        self.eye_class  = eye_class\n",
    "\n",
    "        self.transform = transforms.Compose([\n",
    "            transforms.Resize(img_size),\n",
    "            transforms.ToTensor(),\n",
    "            transforms.Normalize([0.5,0.5,0.5],[0.5,0.5,0.5])])\n",
    "    \n",
    "    ############################## Mask Process ##############################\n",
    "    # mask attribute: 0:background 1:face 2:left-eyebrow 3:right-eyebrow 4:left-eye 5: right-eye 6: nose\n",
    "    # 7: upper-lip 8: teeth 9: under-lip 10:hair 11: left-ear 12: right-ear 13: neck\n",
    "    def mask_process(self, mask: torch.Tensor):\n",
    "        '''\n",
    "        mask: (1, h, w)\n",
    "        '''        \n",
    "        mask_lip = (mask == self.lip_class[0]).float() + (mask == self.lip_class[1]).float()\n",
    "        mask_face = (mask == self.face_class[0]).float() + (mask == self.face_class[1]).float()\n",
    "\n",
    "        #mask_eyebrow_left = (mask == self.eyebrow_class[0]).float()\n",
    "        #mask_eyebrow_right = (mask == self.eyebrow_class[1]).float()\n",
    "        mask_face += (mask == self.eyebrow_class[0]).float()\n",
    "        mask_face += (mask == self.eyebrow_class[1]).float()\n",
    "\n",
    "        mask_eye_left = (mask == self.eye_class[0]).float()\n",
    "        mask_eye_right = (mask == self.eye_class[1]).float()\n",
    "\n",
    "        #mask_list = [mask_lip, mask_face, mask_eyebrow_left, mask_eyebrow_right, mask_eye_left, mask_eye_right]\n",
    "        mask_list = [mask_lip, mask_face, mask_eye_left, mask_eye_right]\n",
    "        mask_aug = torch.cat(mask_list, 0) # (C, H, W)\n",
    "        return mask_aug      \n",
    "\n",
    "    def save_mask(self, mask: torch.Tensor, path):\n",
    "        assert mask.shape[0] == 1\n",
    "        mask = mask.squeeze(0).numpy().astype(np.uint8)\n",
    "        mask = Image.fromarray(mask)\n",
    "        mask.save(path)\n",
    "\n",
    "    def load_mask(self, path):\n",
    "        mask = np.array(Image.open(path.replace('.jpg', '.png')).convert('L'))\n",
    "        mask = torch.FloatTensor(mask).unsqueeze(0)\n",
    "        mask = functional.resize(mask, self.img_size, transforms.InterpolationMode.NEAREST)\n",
    "        return mask\n",
    "    \n",
    "    ############################## Landmarks Process ##############################\n",
    "    def lms_process(self, image:Image):\n",
    "        face = futils.dlib.detect(image)\n",
    "        # face: rectangles, List of rectangles of face region: [(left, top), (right, bottom)]\n",
    "        if not face:\n",
    "            return None\n",
    "        face = face[0]\n",
    "        lms = futils.dlib.landmarks(image, face) * self.img_size / image.width # scale to fit self.img_size\n",
    "        # lms: narray, the position of 68 key points, (68 ,2)\n",
    "        lms = torch.IntTensor(lms.round()).clamp_max_(self.img_size - 1)\n",
    "        # distinguish upper and lower lips \n",
    "        lms[61:64,0] -= 1; lms[65:68,0] += 1\n",
    "        for i in range(3):\n",
    "            if torch.sum(torch.abs(lms[61+i] - lms[67-i])) == 0:\n",
    "                lms[61+i,0] -= 1;  lms[67-i,0] += 1\n",
    "        # double check\n",
    "        '''for i in range(48, 67):\n",
    "            for j in range(i+1, 68):\n",
    "                if torch.sum(torch.abs(lms[i] - lms[j])) == 0:\n",
    "                    lms[i,0] -= 1; lms[j,0] += 1'''\n",
    "        return lms       \n",
    "    \n",
    "    def diff_process(self, lms: torch.Tensor, normalize=False):\n",
    "        '''\n",
    "        lms:(68, 2)\n",
    "        '''\n",
    "        lms = lms.transpose(1, 0).reshape(-1, 1, 1) # (136, 1, 1)\n",
    "        diff = self.fix - lms # (136, h, w)\n",
    "\n",
    "        if normalize:\n",
    "            norm = torch.norm(diff, dim=0, keepdim=True).repeat(diff.shape[0], 1, 1)\n",
    "            norm = torch.where(norm == 0, torch.tensor(1e10), norm)\n",
    "            diff /= norm\n",
    "        return diff\n",
    "\n",
    "    def save_lms(self, lms: torch.Tensor, path):\n",
    "        lms = lms.numpy()\n",
    "        np.save(path, lms)\n",
    "    \n",
    "    def load_lms(self, path):\n",
    "        lms = np.load(path)\n",
    "        return torch.IntTensor(lms)\n",
    "\n",
    "    ############################## Compose Process ##############################\n",
    "    def preprocess(self, image: Image, is_crop=True):\n",
    "        '''\n",
    "        return: image: Image, (H, W), mask: tensor, (1, H, W)\n",
    "        '''\n",
    "        face = futils.dlib.detect(image)\n",
    "        # face: rectangles, List of rectangles of face region: [(left, top), (right, bottom)]\n",
    "        if not face:\n",
    "            return None, None, None\n",
    "\n",
    "        face_on_image = face[0]\n",
    "        if is_crop:\n",
    "            image, face, crop_face = futils.dlib.crop(\n",
    "                image, face_on_image, self.up_ratio, self.down_ratio, self.width_ratio)\n",
    "        else:\n",
    "            face = face[0]; crop_face = None\n",
    "        # image: Image, cropped face\n",
    "        # face: the same as above\n",
    "        # crop face: rectangle, face region in cropped face\n",
    "        np_image = np.array(image) # (h', w', 3)\n",
    "\n",
    "        mask = self.face_parse.parse(cv2.resize(np_image, (512, 512))).cpu()\n",
    "        # obtain face parsing result\n",
    "        # mask: Tensor, (512, 512)\n",
    "        mask = F.interpolate(\n",
    "            mask.view(1, 1, 512, 512),\n",
    "            (self.img_size, self.img_size),\n",
    "            mode=\"nearest\").squeeze(0).long() #(1, H, W)\n",
    "\n",
    "        lms = futils.dlib.landmarks(image, face) * self.img_size / image.width # scale to fit self.img_size\n",
    "        # lms: narray, the position of 68 key points, (68 ,2)\n",
    "        lms = torch.IntTensor(lms.round()).clamp_max_(self.img_size - 1)\n",
    "        # distinguish upper and lower lips \n",
    "        lms[61:64,0] -= 1; lms[65:68,0] += 1\n",
    "        for i in range(3):\n",
    "            if torch.sum(torch.abs(lms[61+i] - lms[67-i])) == 0:\n",
    "                lms[61+i,0] -= 1;  lms[67-i,0] += 1\n",
    "\n",
    "        image = image.resize((self.img_size, self.img_size), Image.ANTIALIAS)\n",
    "        return [image, mask, lms], face_on_image, crop_face\n",
    "    \n",
    "    def process(self, image: Image, mask: torch.Tensor, lms: torch.Tensor):\n",
    "        image = self.transform(image)\n",
    "        mask = self.mask_process(mask)\n",
    "        diff = self.diff_process(lms)\n",
    "        return [image, mask, diff, lms]\n",
    "    \n",
    "    def __call__(self, image:Image, is_crop=True):\n",
    "        source, face_on_image, crop_face = self.preprocess(image, is_crop)\n",
    "        if source is None:\n",
    "            return None, None, None\n",
    "        return self.process(*source), face_on_image, crop_face\n",
    "\n",
    "\n",
    "class TestFixed_Dataset(data.Dataset):\n",
    "    def __init__(self, root=None, dim=(256, 256), img_size=256, test_name=None, prompt='makeup transfer'):\n",
    "        super(TestFixed_Dataset, self).__init__()\n",
    "        self.root = root\n",
    "        with open(os.path.join(self.root, test_name), 'r') as f:\n",
    "            self.makeup_names = [name.strip().split(' ')[1] for name in f.readlines()]\n",
    "        with open(os.path.join(self.root, test_name), 'r') as f:\n",
    "            self.non_makeup_names = [name.strip().split(' ')[0] for name in f.readlines()]\n",
    "        self.preprocessor = PreProcess()\n",
    "        self.img_size = img_size\n",
    "        self.dim = dim\n",
    "\n",
    "    def load_from_file(self, img_name):\n",
    "        image = Image.open(os.path.join(self.root, 'images', img_name)).convert('RGB')\n",
    "        mask = self.preprocessor.load_mask(os.path.join(self.root, 'segs', img_name))\n",
    "        base_name = os.path.splitext(img_name)[0]\n",
    "        lms = self.preprocessor.load_lms(os.path.join(self.root, 'lms', f'{base_name}.npy'))\n",
    "        return self.preprocessor.process(image, mask, lms)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.makeup_names)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        name_s = self.non_makeup_names[index]\n",
    "        name_r = self.makeup_names[index]\n",
    "        basename_s = os.path.basename(name_s).split('.')[0]\n",
    "        basename_r = os.path.basename(name_r).split('.')[0]\n",
    "        basename = '%s&%s' %(basename_s, basename_r)\n",
    "\n",
    "        source = self.load_from_file(name_s)\n",
    "        reference = self.load_from_file(name_r)\n",
    "        \n",
    "        return_dict = {}\n",
    "        return_dict['source'] = source\n",
    "        return_dict['src_img'] = (source[0] + 1) / 2         # [0, 1]\n",
    "        return_dict['reference'] = reference\n",
    "        return_dict['ref_img'] = (reference[0] + 1) / 2\n",
    "        return_dict['img_name'] = basename\n",
    "        return return_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c50a69c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_result(img, img_name, index):\n",
    "    src, ref = img_name.strip().split('&')\n",
    "    sr_name = '%s&%s&%03d.png' %(src, ref, index)\n",
    "    img = (img + 1) / 2\n",
    "    if show:\n",
    "        grid = make_grid(img)\n",
    "        ndarr = grid.mul(255).add_(0.5).clamp_(0, 255).permute(1, 2, 0).to(\"cpu\", torch.uint8).numpy()\n",
    "        im = Image.fromarray(ndarr)\n",
    "        plt.imshow(im)\n",
    "        plt.show()\n",
    "    if save_dir:\n",
    "        save_image(img, os.path.join(save_dir, sr_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16af77bd",
   "metadata": {},
   "source": [
    "## 修改点2 一些配置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "fa7b2e81",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 数据集所在目录\n",
    "data_root = '../../datasets/MT-Dataset'\n",
    "# 数据集配置\n",
    "test_name = 'test_1129.txt'\n",
    "# 1： 只保存生成结果\n",
    "# 3： src+ref+fake\n",
    "save_num = 3\n",
    "# 是否显示图像\n",
    "show = True\n",
    "# 结果保存目录，当设置值为None时，不保存\n",
    "save_dir = './PGT_results'\n",
    "if save_dir:\n",
    "    os.makedirs(save_dir, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "53db45f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "inference = Inference()\n",
    "dataset = TestFixed_Dataset(root=data_root, test_name=test_name)\n",
    "dataloader = DataLoader(dataset, num_workers=2, batch_size=1, shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "882c229d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "device = 'cuda:%s' %(gpu_id)\n",
    "for i, data in enumerate(dataloader):\n",
    "    source = data['source']\n",
    "    reference = data['reference']\n",
    "    ref_img = data['ref_img']\n",
    "    src_img = data['src_img']\n",
    "    image_s, image_r = source[0].cuda(), reference[0].cuda()          \n",
    "    mask_s_full, mask_r_full = source[1].cuda(), reference[1].cuda()  \n",
    "    lms_s, lms_r = source[3].cuda(), reference[3].cuda()   \n",
    "    result = inference(image_s, image_r, mask_s_full, mask_r_full, lms_s, lms_r)\n",
    "    if save_num == 1:\n",
    "        pass\n",
    "    elif save_num == 3:\n",
    "        result = torch.cat((image_s, image_r, result), 0)\n",
    "    img_name = data[\"img_name\"][0]\n",
    "    save_result(result, img_name, i)\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96b1847d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c515d69a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "46f7f744",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "torch_1.13.1",
   "language": "python",
   "name": "torch_1.13.1"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
